home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 19 / CU Amiga Magazine's Super CD-ROM 19 (1998)(EMAP Images)(GB)[!][issue 1998-02].iso / CUCD / Programming / LEDA / source / src / arith / imem.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-16  |  3.9 KB  |  206 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  imem.c
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16. /*        imem.c        RD, 05.04.90    */
  17.  
  18. #include <LEDA/impl/iint.h>
  19. #include <LEDA/impl/iloc.h>
  20.  
  21. #define I_STATISTICS
  22.  
  23. _VOID_ Iprint_statistics(_VOID_)
  24. {
  25. }
  26.  
  27. char * Imalloc(i)
  28.     int i;
  29. {    return (char*)MYMALLOC(i);
  30. }
  31.  
  32. void Ifree(u)
  33.     char * u;
  34. {    MYFREE(u);
  35. }
  36.  
  37. /*#define MEMLISTMAX 16*/
  38. #define MEMLISTMAX 32
  39. #define MEMLISTMIN 2
  40.  
  41. typedef union uMemEl {
  42.         union uMemEl *next;
  43.         PLACE mem;
  44. } MemEl, *pMemEl;
  45.  
  46. typedef struct sMemList {
  47.         pMemEl free;
  48.         int size;
  49. } tMemList;
  50.  
  51. static tMemList MemList[MEMLISTMAX];
  52. static BOOLEAN MemListInit=FALSE;
  53.  
  54. #ifdef I_STATISTICS
  55. static long    Ivec_used[MEMLISTMAX];
  56. static long    Ivec_allocated[MEMLISTMAX];
  57. #endif
  58.  
  59. PLACE * newvec(maxl)
  60.         int *maxl;
  61. {       register int i; 
  62.         register pMemEl u;
  63.         register int a, ml;
  64.         if (!MemListInit) {
  65.                 int j=2;
  66.         MemListInit=TRUE;
  67.                 for (i=1; i<MEMLISTMAX; i++) {
  68.                         MemList[i].size=j;
  69.             MemList[i].free=NULL;
  70.                         j<<=1;
  71. #ifdef I_STATISTICS
  72.             Ivec_used[i]=0;
  73.             Ivec_allocated[i]=0;
  74. #endif
  75.                 }
  76.     }
  77.         a=*maxl;
  78.         i=MEMLISTMIN;
  79.     if (a) {
  80.         a--;
  81.         a>>=i;
  82.         while(a) {
  83.                 a>>=1;
  84.                 i++;
  85.         }
  86.         if (i>=MEMLISTMAX)
  87.         Ierror("newvec: exceeded MEMLISTMAX\n");
  88.     }
  89.         ml=MemList[i].size;
  90.         *maxl=ml;
  91.         u=MemList[i].free;
  92.         if (u) {
  93.                 MemList[i].free=u->next;
  94. #ifdef I_STATISTICS
  95.         Ivec_used[i]++;
  96. #endif
  97.                 return (pPLACE)u;
  98.         } else {
  99.                 u=(pMemEl)MYMALLOC(ml*sizeof(PLACE));
  100.         if (!u) {
  101.             int j;
  102.             for (j=1; j<MEMLISTMAX; j++) {
  103.             while (u=MemList[j].free) {
  104.                 MemList[j].free=u->next;
  105.                 MYFREE((char *)u);
  106.             }
  107.             }
  108.             u=(pMemEl)MYMALLOC(ml*sizeof(PLACE));
  109.             if(!u) {
  110. #ifdef I_STATISTICS
  111.             Iprint_statistics();
  112. #endif
  113.             Ierror("newvec: memory full\n");
  114.             }
  115.         }
  116. #ifdef I_STATISTICS
  117.         Ivec_used[i]++;
  118.         Ivec_allocated[i]++;
  119. #endif
  120.                 return (pPLACE)u;
  121. }       }               /* newvec */
  122.  
  123. void delvec(u, maxl)
  124.         PLACE * u; register int maxl;
  125. {       register int i;
  126.     register pMemEl v;
  127.     v=(pMemEl) u;
  128.         i=MEMLISTMIN;
  129.     maxl--;
  130.     maxl>>=i;
  131.     while(maxl) {
  132.                 maxl>>=1;
  133.                 i++;
  134.         }
  135.         v->next=MemList[i].free;
  136.         MemList[i].free=v;
  137. #ifdef I_STATISTICS
  138.     Ivec_used[i]--;
  139. #endif
  140. }        /* delvec */
  141.  
  142. /*************************************/
  143.  
  144. static Integer * Ifreelist=NULL;
  145.  
  146. #ifdef I_STATISTICS
  147. static long    Ihead_used=0;
  148. static long    Ihead_allocated=0;
  149. #endif
  150.  
  151. Integer * newInteger()
  152. {       register Integer * u;
  153.     if (Ifreelist) {
  154.         u=Ifreelist;
  155.         Ifreelist=(Integer *)(u->vec);
  156. #ifdef I_STATISTICS
  157.         Ihead_used++;
  158. #endif
  159.         return u;
  160.     } else {
  161.         u=(Integer *) MYMALLOC(sizeof(Integer));
  162.         if (!u) {
  163. #ifdef I_STATISTICS
  164.             Iprint_statistics();
  165. #endif
  166.             Ierror("newInteger: memory full\n");
  167.         }
  168. #ifdef I_STATISTICS
  169.         Ihead_used++;
  170.         Ihead_allocated++;
  171. #endif
  172.         return u;
  173.     }
  174. }        /* newInteger */
  175.  
  176. void delInteger(u)
  177.     register Integer *u;
  178. {    u->vec = (PLACE *) Ifreelist;
  179.     Ifreelist=u;
  180. #ifdef I_STATISTICS
  181.         Ihead_used--;
  182. #endif
  183. }        /* delInteger */
  184.  
  185. /*
  186. #ifdef I_STATISTICS
  187. _VOID_ Iprint_statistics(_VOID_)
  188. {    int i;
  189.     fprintf(stderr,"\nInteger memory management statistics:\n");
  190.     fprintf(stderr,"Integer structs: %ld allocated, %ld used.\n",
  191.         Ihead_used, Ihead_allocated);
  192.     fprintf(stderr,
  193.         "  size(PLACEs)  size(bytes)   allocated     used\n");
  194.     for (i=1; i<MEMLISTMAX; i++) {
  195.         fprintf(stderr, "%10d    %10d    %10ld    %10ld\n",
  196.             MemList[i].size, MemList[i].size*sizeof(PLACE),
  197.             Ivec_allocated[i], Ivec_used[i]);
  198.     }
  199. }
  200. #else
  201. _VOID_ Iprint_statistics(_VOID_)
  202. {
  203. }
  204. #endif
  205. */
  206.